Keras তে বেসিক Neural Network তৈরি

Keras ব্যবহার করে একটি বেসিক নিউরাল নেটওয়ার্ক তৈরি করা খুবই সহজ এবং এটি দ্রুত মডেল তৈরির জন্য একটি শক্তিশালী টুল। এখানে আমরা একটি সাধারণ ফিডফরওয়ার্ড নিউরাল নেটওয়ার্ক (Fully Connected Neural Network) তৈরি করব যা একটি সহজ Classification সমস্যার সমাধান করবে। এই উদাহরণে আমরা Keras এর Sequential মডেল ব্যবহার করব, যেটি লেয়ারের সিরিজ ব্যবহার করে মডেল তৈরি করে।

১. প্রথমে প্রয়োজনীয় লাইব্রেরি ইনস্টল করুন:

যদি আপনি Keras ইনস্টল না করে থাকেন, তাহলে এটি প্রথমে ইনস্টল করুন। আপনি tensorflow প্যাকেজ ইনস্টল করলে এটি স্বয়ংক্রিয়ভাবে Keras ইনস্টল করে দেয়।

pip install tensorflow

২. কোড উদাহরণ: বেসিক Neural Network তৈরি করা

এখানে আমরা একটি সাধারণ নিউরাল নেটওয়ার্ক তৈরি করব যা MNIST ডেটাসেট (যেখানে হাতের লেখা ডিজিট থাকে) ব্যবহার করে ডিজিট চেনার কাজ করবে।

import tensorflow as tf
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense
from tensorflow.keras.datasets import mnist
from tensorflow.keras.utils import to_categorical

# MNIST ডেটাসেট লোড করা
(X_train, y_train), (X_test, y_test) = mnist.load_data()

# ডেটাকে [0, 1] রেঞ্জে স্কেল করা
X_train = X_train / 255.0
X_test = X_test / 255.0

# আউটপুট (লেবেল) কে one-hot encoding এ রূপান্তর করা
y_train = to_categorical(y_train, 10)
y_test = to_categorical(y_test, 10)

# মডেল তৈরি করা
model = Sequential()

# ইনপুট লেয়ার এবং প্রথম হিডেন লেয়ার
model.add(Dense(128, activation='relu', input_shape=(28*28,)))

# ডেটাকে একটি একক ভেক্টরে রূপান্তর করা
model.add(Dense(64, activation='relu'))

# আউটপুট লেয়ার (10টি শ্রেণী, কারণ MNIST এ 0-9 পর্যন্ত 10টি সংখ্যা রয়েছে)
model.add(Dense(10, activation='softmax'))

# মডেল কম্পাইল করা
model.compile(optimizer='adam', loss='categorical_crossentropy', metrics=['accuracy'])

# মডেল সারাংশ দেখা
model.summary()

# মডেল প্রশিক্ষণ
model.fit(X_train.reshape(-1, 28*28), y_train, epochs=5, batch_size=32)

# মডেল মূল্যায়ন
test_loss, test_acc = model.evaluate(X_test.reshape(-1, 28*28), y_test)
print('Test accuracy:', test_acc)

কোড বিশ্লেষণ

1. ডেটাসেট লোড করা:
   • আমরা MNIST ডেটাসেট ব্যবহার করছি যা 28x28 আকারের হাতের লেখা সংখ্যা (0 থেকে 9 পর্যন্ত) রয়েছে।
   • X_train এবং X_test হল ইনপুট ইমেজ, এবং y_train এবং y_test হল লেবেল (সংখ্যাগুলোর)।
2. ডেটা স্কেলিং:
   • ডেটার মানকে [0, 1] রেঞ্জে আনতে, আমরা সব ইমেজকে 255 দ্বারা ভাগ করে দিয়েছি, কারণ MNIST এর পিক্সেলের মান 0 থেকে 255 এর মধ্যে।
3. one-hot encoding:
   • y_train এবং y_test লেবেল গুলিকে one-hot encoding ফরম্যাটে রূপান্তর করা হয়েছে, যাতে আউটপুট লেয়ারটি একাধিক শ্রেণী (digits 0-9) শনাক্ত করতে পারে।
4. মডেল তৈরি:
   • আমরা একটি Sequential মডেল তৈরি করেছি যা একটি একটির পর এক লেয়ার যোগ করে তৈরি করা হয়েছে।
   • প্রথম লেয়ারটি 128 ইউনিটের একটি ফুলি কানেকটেড (Dense) লেয়ার যার অ্যাকটিভেশন ফাংশন ReLU। ইনপুট আকার (28*28,)। এখানে আমরা ইনপুট ডেটাকে 28x28 আকার থেকে একক ভেক্টরে (784 আকারে) রূপান্তর করেছি।
   • দ্বিতীয় লেয়ারটি 64 ইউনিটের আরেকটি ReLU লেয়ার।
   • আউটপুট লেয়ারটি softmax অ্যাকটিভেশন ফাংশন সহ 10টি ইউনিটের লেয়ার যা 0-9 পর্যন্ত সংখ্যাগুলির শ্রেণী নির্ধারণ করবে।
5. মডেল কম্পাইল করা:
   • মডেলকে Adam অপটিমাইজার, categorical_crossentropy লস ফাংশন এবং accuracy মেট্রিকস দিয়ে কম্পাইল করা হয়েছে।
6. মডেল প্রশিক্ষণ:
   • আমরা model.fit() ফাংশনটি ব্যবহার করে মডেলকে প্রশিক্ষণ দিচ্ছি। এখানে epochs=5 নির্দেশ করে যে মডেলটি 5 বার ডেটাসেট দেখে ট্রেন হবে এবং batch_size=32 মানে একবারে 32টি উদাহরণ ব্যবহৃত হবে।
7. মডেল মূল্যায়ন:
   • প্রশিক্ষণ শেষে, আমরা model.evaluate() ফাংশন ব্যবহার করে টেস্ট ডেটা সেটের উপর মডেলটির পারফরম্যান্স মূল্যায়ন করছি। এটি টেস্ট ডেটার উপর লস এবং একিউরেসি রিটার্ন করবে।

আউটপুট:

যখন আপনি কোডটি চালাবেন, আপনি কিছু এরকম আউটপুট দেখতে পাবেন:

Epoch 1/5
1875/1875 [==============================] - 3s 2ms/step - loss: 0.2610 - accuracy: 0.9254
Epoch 2/5
1875/1875 [==============================] - 3s 2ms/step - loss: 0.1145 - accuracy: 0.9646
Epoch 3/5
1875/1875 [==============================] - 3s 2ms/step - loss: 0.0763 - accuracy: 0.9765
Epoch 4/5
1875/1875 [==============================] - 3s 2ms/step - loss: 0.0572 - accuracy: 0.9821
Epoch 5/5
1875/1875 [==============================] - 3s 2ms/step - loss: 0.0437 - accuracy: 0.9861
Test accuracy: 0.979

এখানে, আমরা দেখতে পাচ্ছি যে accuracy প্রশিক্ষণ ডেটাসেটের জন্য 98.61% এবং test accuracy প্রায় 97.9% ছিল।

সারাংশ:

এটি একটি বেসিক নিউরাল নেটওয়ার্ক মডেল তৈরি করার উদাহরণ যেখানে Keras ব্যবহার করে ইনপুট ডেটা নিয়ে একটি ফিডফরওয়ার্ড মডেল তৈরি করা হয়েছে। এই মডেলটি একাধিক লেয়ার ব্যবহার করে এবং ReLU ও Softmax অ্যাকটিভেশন ফাংশন প্রয়োগ করে ডিজিট ক্লাসিফিকেশন কাজ করেছে। Keras এর সহজ API ব্যবহার করে দ্রুত মডেল তৈরি এবং প্রশিক্ষণ সম্ভব।

Sequential মডেল Keras-এর একটি সহজ এবং জনপ্রিয় মডেল আর্কিটেকচার। এটি এমন একটি মডেল যেখানে লেয়ারগুলো একটি লিনিয়ার স্ট্যাক হিসাবে সাজানো থাকে, অর্থাৎ প্রতিটি লেয়ার শুধুমাত্র তার আগের লেয়ার থেকে ইনপুট নেয় এবং আউটপুট প্রেরণ করে পরবর্তী লেয়ারকে। এটি সাধারণত ফিডফরওয়ার্ড নিউরাল নেটওয়ার্ক বা সাধারণ নিউরাল নেটওয়ার্কের জন্য ব্যবহৃত হয়।

এখানে কিভাবে একটি Sequential মডেল তৈরি করা যায় তার একটি উদাহরণ দেওয়া হলো।

Sequential মডেল তৈরি করার পদ্ধতি

১. মডেল তৈরি করা:

Sequential মডেল তৈরি করতে, আপনি tensorflow.keras.models.Sequential ক্লাস ব্যবহার করবেন। এর মাধ্যমে একটি সোজা স্ট্যাক তৈরি করা হয় যেখানে লেয়ারগুলো একে একে যোগ করা হয়।

২. লেয়ার যোগ করা:

এখানে Dense লেয়ার (পুরোসংযোগী লেয়ার) ব্যবহার করা হয়েছে, যা বেশিরভাগ নিউরাল নেটওয়ার্কে সাধারণত ব্যবহৃত হয়।

৩. মডেল কম্পাইল করা:

মডেল তৈরির পর, compile() ফাংশন ব্যবহার করে মডেল কম্পাইল করতে হবে, যেখানে অপটিমাইজার, লস ফাংশন এবং মেট্রিক্স নির্ধারণ করতে হবে।

৪. মডেল প্রশিক্ষণ:

মডেল তৈরি এবং কম্পাইল করার পর, fit() ফাংশন ব্যবহার করে মডেলকে প্রশিক্ষণ দেওয়া হবে।

উদাহরণ:

import tensorflow as tf
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense

# Sequential মডেল তৈরি
model = Sequential()

# ইনপুট লেয়ার
model.add(Dense(64, input_dim=8, activation='relu'))

# হিডেন লেয়ার
model.add(Dense(32, activation='relu'))

# আউটপুট লেয়ার
model.add(Dense(1, activation='sigmoid'))

# মডেল কম্পাইল করা
model.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy'])

# মডেল সংক্ষিপ্ত সারাংশ দেখানো
model.summary()

# মডেল প্রশিক্ষণ (X_train এবং y_train হলো প্রশিক্ষণ ডেটা)
model.fit(X_train, y_train, epochs=10, batch_size=32)

বর্ণনা:

1. Sequential মডেল তৈরি:
   • model = Sequential() দিয়ে মডেল তৈরি করা হয়েছে। এটি একটি লিনিয়ার স্ট্যাকিংয়ের মাধ্যমে লেয়ার যোগ করার সুযোগ দেয়।
2. ইনপুট লেয়ার:
   • প্রথম Dense লেয়ারের মাধ্যমে ৮টি ইনপুট ফিচার নিয়ে ৬৪টি নিউরন আউটপুট দেওয়া হয়েছে, যেখানে ReLU (Rectified Linear Unit) অ্যাক্টিভেশন ফাংশন ব্যবহার করা হয়েছে।
3. হিডেন লেয়ার:
   • দ্বিতীয় Dense লেয়ারে ৩২টি নিউরন এবং আবার ReLU অ্যাক্টিভেশন ফাংশন ব্যবহার করা হয়েছে।
4. আউটপুট লেয়ার:
   • আউটপুট লেয়ারটি ১টি নিউরন নিয়ে Sigmoid অ্যাক্টিভেশন ফাংশন ব্যবহার করা হয়েছে, যা বাইনারি ক্লাসিফিকেশন সমস্যার জন্য উপযুক্ত।
5. মডেল কম্পাইল করা:
   • loss='binary_crossentropy': বাইনারি ক্লাসিফিকেশন সমস্যার জন্য লস ফাংশন।
   • optimizer='adam': অ্যাডাম অপটিমাইজার ব্যবহার করা হয়েছে, যা একটি জনপ্রিয় অপটিমাইজেশন অ্যালগরিদম।
   • metrics=['accuracy']: মডেলের কার্যকারিতা যাচাই করার জন্য accuracy মেট্রিক ব্যবহার করা হয়েছে।
6. মডেল প্রশিক্ষণ:
   • model.fit(X_train, y_train, epochs=10, batch_size=32) ফাংশনের মাধ্যমে মডেলটি ১০টি এপোক (epoch) ধরে প্রশিক্ষিত হবে।

সারাংশ

Sequential মডেল Keras-এ খুবই সহজ এবং সাধারণ মডেল আর্কিটেকচার যা একের পর এক লেয়ার যোগ করার মাধ্যমে তৈরি হয়। এটি সাধারণত ছোট এবং সরল নিউরাল নেটওয়ার্কের জন্য ব্যবহার করা হয়, যেখানে ইনপুট থেকে আউটপুট পর্যন্ত একটি একক লিনিয়ার পাথ থাকে।

Dense Layer এবং Activation Functions হল নিউরাল নেটওয়ার্কের দুটি গুরুত্বপূর্ণ উপাদান। Dense Layer হল একটি পূর্ণসংখ্যক সংযোগ (fully connected layer) যেখানে প্রতিটি ইনপুট নিউরন একটি করে আউটপুট নিউরনের সাথে সংযুক্ত থাকে। অন্যদিকে Activation Functions নেটওয়ার্কের প্রতিটি লেয়ারের আউটপুট পরবর্তী লেয়ারের জন্য নির্ধারণ করে।

নিচে Dense Layer এবং Activation Functions (ReLU, Sigmoid, Softmax) সম্পর্কে বিস্তারিত আলোচনা করা হয়েছে।

১. Dense Layer:

Dense Layer বা Fully Connected Layer একটি সাধারণ ন্যূনতম নিউরাল নেটওয়ার্ক লেয়ার যা ইনপুট এবং আউটপুট নিউরনের মধ্যে পুরোপুরি সংযুক্ত থাকে।

Dense Layer সাধারণভাবে Dense(units, activation) ফাংশন হিসেবে ব্যবহার করা হয়। এখানে:

• units: আউটপুট নিউরনের সংখ্যা (এটি লেয়ারের আউটপুটের আকার নির্ধারণ করে)।
• activation: ব্যবহার করা অ্যাক্টিভেশন ফাংশন।

উদাহরণ:

from tensorflow.keras.layers import Dense

# Dense Layer তৈরি করা
model.add(Dense(units=64, activation='relu', input_dim=8))  # ইনপুট ডাইমেনশন ৮ এবং ৬৪ আউটপুট

এখানে, units=64 বলে দিচ্ছে যে এই লেয়ারের ৬৪টি আউটপুট নিউরন থাকবে, এবং ReLU অ্যাক্টিভেশন ফাংশন ব্যবহার করা হবে।

২. Activation Functions:

Activation Functions হল সেগুলি যা নিউরাল নেটওয়ার্কের প্রতিটি লেয়ারের আউটপুট নির্ধারণ করে। এটি ইনপুট সিগন্যালের একটি ট্রান্সফরমেশন, যা নেটওয়ার্কের শিখন ক্ষমতা এবং কর্মক্ষমতাকে প্রভাবিত করে। অ্যাক্টিভেশন ফাংশনের বেশ কয়েকটি ধরন রয়েছে, যার মধ্যে ReLU, Sigmoid, এবং Softmax অন্যতম।

২.১ ReLU (Rectified Linear Unit):

ReLU হল সবচেয়ে জনপ্রিয় অ্যাক্টিভেশন ফাংশন যা সাধারণত হিডেন লেয়ারগুলিতে ব্যবহৃত হয়। এটি ইনপুট পজিটিভ হলে আউটপুট হিসাবে ইনপুটকে ফেরত দেয় এবং ইনপুট নেগেটিভ হলে আউটপুট ০ ফেরত দেয়।

ReLU ফাংশন:

$$f(x) = \max(0, x)$$

ReLU এর সুবিধা:

• সহজ এবং দ্রুত গণনা করা যায়।
• পজিটিভ ইনপুটে লিনিয়ার আউটপুট প্রদান করে, যা দ্রুত শিখন প্রক্রিয়া নিশ্চিত করে।

ReLU এর অসুবিধা:

• Vanishing Gradient Problem: যদি ইনপুট খুব বেশি নেগেটিভ হয় তবে আউটপুট ০ হয়ে যায়, ফলে ব্যাকপ্রোপাগেশন প্রক্রিয়ায় গ্রেডিয়েন্ট (gradient) বিলুপ্ত হয়ে যেতে পারে।

উদাহরণ:

from tensorflow.keras.layers import Dense

model.add(Dense(units=64, activation='relu', input_dim=8))  # ReLU অ্যাক্টিভেশন ব্যবহার করা

২.২ Sigmoid:

Sigmoid হল একটি সিগময়েড ফাংশন যা আউটপুটকে ০ থেকে ১ এর মধ্যে স্কেল করে। এটি সাধারণত output layer এর জন্য ব্যবহৃত হয়, যেখানে আউটপুট দুটি ক্লাসে বিভক্ত করা হয় (যেমন বাইনারি শ্রেণীবিভাজন)।

Sigmoid ফাংশন:

$$f(x) = \frac{1}{1 + e^{-x}}$$

Sigmoid এর সুবিধা:

• আউটপুট ০ থেকে ১ এর মধ্যে থাকে, যা প্রবণতা পেতে সহায়ক (যেমন, সম্ভাবনা বা প্রোবাবিলিটি হিসেবে ব্যবহার করা যেতে পারে)।
• বাইনারি শ্রেণীবিভাজন সমস্যার জন্য আদর্শ।

Sigmoid এর অসুবিধা:

• Vanishing Gradient Problem: ইনপুটের মান খুব বেশি হলে গ্রেডিয়েন্ট বিলুপ্ত হতে পারে।
• আউটপুটটি ০ বা ১ এর মধ্যে সীমাবদ্ধ হওয়ায়, উচ্চ মানের ইনপুটে কার্যকরী হতে পারে না।

উদাহরণ:

from tensorflow.keras.layers import Dense

model.add(Dense(units=1, activation='sigmoid'))  # Sigmoid অ্যাক্টিভেশন ব্যবহার করা

২.৩ Softmax:

Softmax ফাংশন সাধারণত মাল্টিক্লাস শ্রেণীবিভাজন সমস্যায় আউটপুট লেয়ারে ব্যবহৃত হয়। এটি আউটপুটকে একটি প্রোবাবিলিটি ভেক্টরে পরিণত করে, যার মান ০ এবং ১ এর মধ্যে থাকে এবং সমস্ত আউটপুটের যোগফল ১ হয়। এই প্রোবাবিলিটি সবার জন্য শ্রেণী নির্বাচন করতে ব্যবহৃত হয়।

Softmax ফাংশন:

$$f(x_i) = \frac{e^{x_i}}{\sum_{j=1}^{n} e^{x_j}}$$

যেখানে $x_i$ হল ইনপুটের প্রতিটি ভ্যালু এবং $n$ হল আউটপুট নিউরনের সংখ্যা।

Softmax এর সুবিধা:

• মাল্টিক্লাস শ্রেণীবিভাজন সমস্যার জন্য আদর্শ।
• প্রোবাবিলিটি হিসাবে আউটপুট প্রদানে উপকারী।

Softmax এর অসুবিধা:

• কিছুটা ধীর গণনা হতে পারে যদি আউটপুট নিউরন সংখ্যা অনেক বেশি হয়।

উদাহরণ:

from tensorflow.keras.layers import Dense

model.add(Dense(units=3, activation='softmax'))  # Softmax অ্যাক্টিভেশন ব্যবহার করা

এখানে units=3 নির্দেশ করছে যে ৩টি শ্রেণী রয়েছে এবং Softmax ফাংশন তাদের মধ্যে প্রোবাবিলিটি প্রদান করবে।

সারাংশ:

1. Dense Layer:
   • একটি পূর্ণসংখ্যক সংযোগিত লেয়ার, যেখানে প্রতিটি ইনপুট নিউরন প্রতিটি আউটপুট নিউরনের সাথে সংযুক্ত থাকে।
   • এর জন্য Dense(units, activation) ফাংশন ব্যবহার করা হয়।
2. Activation Functions:
   • ReLU (Rectified Linear Unit): ইনপুট পজিটিভ হলে ইনপুট ফেরত দেয় এবং নেগেটিভ হলে ০ ফেরত দেয়। এটি সাধারণত হিডেন লেয়ারগুলিতে ব্যবহৃত হয়।
   • Sigmoid: আউটপুট ০ থেকে ১ এর মধ্যে স্কেল করে, সাধারণত বাইনারি শ্রেণীবিভাজন সমস্যায় ব্যবহৃত হয়।
   • Softmax: মাল্টিক্লাস শ্রেণীবিভাজন সমস্যায় আউটপুটকে প্রোবাবিলিটিতে রূপান্তরিত করে, যেখানে সমস্ত আউটপুটের যোগফল ১ হয়।

ডীপ লার্নিং মডেল কম্পাইল করার সময়, দুটি গুরুত্বপূর্ণ উপাদান Loss Function এবং Optimizer নির্বাচন করা হয়। এগুলি মডেল প্রশিক্ষণের জন্য অত্যন্ত গুরুত্বপূর্ণ, কারণ Loss Function নির্ধারণ করে কতটা ভুল মডেল করছে, এবং Optimizer মডেলের সঠিক প্যারামিটার আপডেট করতে সহায়তা করে।

নিচে Loss Function এবং Optimizer সম্পর্কিত বিস্তারিত আলোচনা করা হলো।

১. Loss Function (লস ফাংশন)

Loss Function একটি গণনা পদ্ধতি যা প্রশিক্ষণ ডেটা এবং মডেল আউটপুটের মধ্যে ব্যবধান (অথবা ভুল) পরিমাপ করে। এটি মডেলের মানসিকতা বা সিদ্ধান্তের কতটা ভুল হয়েছে তা চিহ্নিত করে, এবং মডেলকে পরবর্তী ইটারেশনে আরও ভালভাবে কাজ করার জন্য আপডেট করতে সাহায্য করে।

প্রধান Loss Functions:

1. Mean Squared Error (MSE):

   • এটি রিগ্রেশন প্রজেক্টে ব্যবহৃত হয় যেখানে আউটপুট একটি ক্রমাগত ভেরিয়েবল।
   • গণনা:

   $$MSE = \frac{1}{n} \sum_{i=1}^{n} (y_{\text{true}}^i - y_{\text{pred}}^i)^2$$

   • যখন আপনার লক্ষ্য একটি নির্দিষ্ট মান পূর্বাভাস করা (যেমন: ভবিষ্যদ্বাণী করা বা ক্রমাগত আউটপুট)।

   Keras কোড:

   model.compile(optimizer='adam', loss='mean_squared_error')
   

2. Binary Crossentropy:

   • এটি বাইনারি ক্লাসিফিকেশন সমস্যায় ব্যবহৃত হয়, যেখানে আউটপুট দুটি শ্রেণিতে বিভক্ত থাকে (যেমন: 0 অথবা 1)।
   • গণনা:

   $$\text{Binary Crossentropy} = -\left( y_{\text{true}} \cdot \log(y_{\text{pred}}) + (1 - y_{\text{true}}) \cdot \log(1 - y_{\text{pred}}) \right)$$

   • যখন আপনার দুটি শ্রেণী থাকে এবং প্রতিটি আউটপুটের জন্য সম্ভাবনা নির্ধারণ করতে হয়।

   Keras কোড:

   model.compile(optimizer='adam', loss='binary_crossentropy')
   

3. Categorical Crossentropy:

   • এটি মাল্টিক্লাস ক্লাসিফিকেশন সমস্যার জন্য ব্যবহৃত হয় যেখানে আউটপুট অনেক শ্রেণিতে বিভক্ত থাকে (যেমন: কুকুর, বিড়াল, পাখি)।
   • গণনা:

   $$\text{Categorical Crossentropy} = -\sum_{i=1}^{C} y_{\text{true}}^i \log(y_{\text{pred}}^i)$$

   • এটি যদি একাধিক শ্রেণীর মধ্যে সঠিক শ্রেণী নির্বাচন করতে হয়, তবে এটি ব্যবহৃত হয়।

   Keras কোড:

   model.compile(optimizer='adam', loss='categorical_crossentropy')
   

4. Sparse Categorical Crossentropy:

   • এটি Categorical Crossentropy এর মতো, তবে লক্ষ্য (labels) একক সংখ্যা (যেমন 0, 1, 2) আকারে থাকে, আর Categorical Crossentropy এর জন্য target values একহটী (one-hot encoded) আকারে থাকে।

   Keras কোড:

   model.compile(optimizer='adam', loss='sparse_categorical_crossentropy')
   

২. Optimizer (অপটিমাইজার)

Optimizer হল একটি অ্যালগোরিদম যা মডেলের প্যারামিটারগুলোকে আপডেট করে মডেলকে প্রশিক্ষণ করতে সহায়তা করে। এটি Loss Function এর মান কমাতে চেষ্টা করে, যাতে মডেল আরও ভালভাবে কাজ করে।

প্রধান Optimizers:

1. Stochastic Gradient Descent (SGD):

   • এটি সবচেয়ে মৌলিক অপটিমাইজার এবং Gradient Descent অ্যালগোরিদমের একটি রূপ।
   • এটি সর্বনিম্ন লস ফাংশন খুঁজে বের করার জন্য প্যারামিটারগুলিকে গ্রেডিয়েন্ট অনুসারে আপডেট করে।

   Keras কোড:

   from tensorflow.keras.optimizers import SGD
   model.compile(optimizer=SGD(), loss='mean_squared_error')
   

2. Adam (Adaptive Moment Estimation):

   • Adam অপটিমাইজার হলো SGD এর একটি উন্নত সংস্করণ যা momentum এবং adaptive learning rate ব্যবহার করে।
   • এটি মডেল প্রশিক্ষণের জন্য দ্রুত এবং স্থিতিশীল আপডেট প্রদান করে।

   Keras কোড:

   from tensorflow.keras.optimizers import Adam
   model.compile(optimizer=Adam(), loss='binary_crossentropy')
   

3. RMSprop (Root Mean Square Propagation):

   • RMSprop অপটিমাইজার Adam এর মতো, তবে এটি এমনভাবে কাজ করে যে, প্রতি গ্রেডিয়েন্ট আপডেটের জন্য আরও নির্দিষ্ট লার্নিং রেট নির্বাচন করা হয়।
   • এটি বিশেষভাবে RNN বা অনুক্রমিক ডেটার জন্য কার্যকর।

   Keras কোড:

   from tensorflow.keras.optimizers import RMSprop
   model.compile(optimizer=RMSprop(), loss='mean_squared_error')
   

4. Adagrad (Adaptive Gradient Algorithm):

   • Adagrad অপটিমাইজার গ্রেডিয়েন্টের সাইজের ভিত্তিতে আলাদা আলাদা লার্নিং রেট নির্ধারণ করে, যাতে সাধারণত বৃহত আউটপুটের জন্য ছোট লার্নিং রেট ব্যবহার করা হয়।

   Keras কোড:

   from tensorflow.keras.optimizers import Adagrad
   model.compile(optimizer=Adagrad(), loss='binary_crossentropy')
   

5. Adadelta:

   • Adadelta অপটিমাইজার Adagrad এর উন্নত সংস্করণ, যেটি পূর্ববর্তী আপডেটগুলি বেশি গুরুত্ব দেয় এবং লার্নিং রেট সীমিত রাখে।

   Keras কোড:

   from tensorflow.keras.optimizers import Adadelta
   model.compile(optimizer=Adadelta(), loss='categorical_crossentropy')
   

মডেল কম্পাইল করা উদাহরণ

এখন, একটি সাধারণ Neural Network মডেল তৈরি করে, এতে Loss Function এবং Optimizer কিভাবে কাজ করে তা দেখানো হবে:

from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense
from tensorflow.keras.optimizers import Adam

# মডেল তৈরি করা
model = Sequential()
model.add(Dense(64, input_dim=8, activation='relu'))  # ইনপুট লেয়ার
model.add(Dense(32, activation='relu'))  # হিডেন লেয়ার
model.add(Dense(1, activation='sigmoid'))  # আউটপুট লেয়ার

# মডেল কম্পাইল করা
model.compile(optimizer=Adam(), loss='binary_crossentropy', metrics=['accuracy'])

# প্রশিক্ষণ
model.fit(X_train, y_train, epochs=10, batch_size=32)

এখানে:

• Loss Function: binary_crossentropy, যা বাইনারি ক্লাসিফিকেশন সমস্যার জন্য উপযুক্ত।
• Optimizer: Adam(), যেটি একটি শক্তিশালী অপটিমাইজার যা দ্রুত এবং কার্যকর প্রশিক্ষণ প্রদান করে।

সারাংশ

• Loss Function: এটি মডেলের ভুল পরিমাপ করে এবং মডেলকে সঠিক আউটপুটের দিকে পরিচালিত করতে সাহায্য করে।
• Optimizer: এটি মডেলের প্যারামিটার আপডেট করে যাতে মডেল আরও ভালভাবে কাজ করে।
• Keras তে model.compile ফাংশন ব্যবহার করে আপনি Loss Function এবং Optimizer নির্বাচন করতে পারেন, যা মডেল প্রশিক্ষণের জন্য গুরুত্বপূর্ণ উপাদান।

ডীপ লার্নিং বা মেশিন লার্নিং মডেল ট্রেনিং এবং মূল্যায়ন (evaluation) একটি গুরুত্বপূর্ণ প্রক্রিয়া যা মডেলের পারফরম্যান্স নির্ধারণে সহায়ক। এখানে Keras এবং TensorFlow ব্যবহার করে মডেল ট্রেনিং এবং ইভ্যালুয়েশন করার জন্য প্রয়োজনীয় পদক্ষেপ এবং কোড উদাহরণ দেওয়া হয়েছে।

১. মডেল ট্রেনিং (Model Training)

মডেল ট্রেনিং হল সেই প্রক্রিয়া যার মাধ্যমে মডেল বিভিন্ন ইনপুট ডেটার মাধ্যমে শেখে এবং প্রতিটি ইনপুটের জন্য সঠিক আউটপুট দেওয়া শেখে। মডেল ট্রেনিং সাধারণত ফিচার ডেটা (X_train) এবং লেবেল (Y_train) এর উপর ভিত্তি করে হয়।

১.১ মডেল ট্রেনিং কোড:

নিচে একটি সাধারণ নিউরাল নেটওয়ার্ক মডেল তৈরি এবং ট্রেনিং করার উদাহরণ দেওয়া হল:

import tensorflow as tf
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense
from tensorflow.keras.optimizers import Adam

# মডেল তৈরি করা
model = Sequential()

# ইনপুট লেয়ার
model.add(Dense(64, input_dim=8, activation='relu'))

# হিডেন লেয়ার
model.add(Dense(32, activation='relu'))

# আউটপুট লেয়ার
model.add(Dense(1, activation='sigmoid'))

# মডেল কম্পাইল করা
model.compile(loss='binary_crossentropy', 
              optimizer=Adam(), 
              metrics=['accuracy'])

# ডেটা তৈরি করা
import numpy as np
X_train = np.random.rand(100, 8)  # 100 উদাহরণ, 8 ইনপুট ফিচার
y_train = np.random.randint(0, 2, 100)  # 100 লেবেল (0 বা 1)

# মডেল প্রশিক্ষণ
model.fit(X_train, y_train, epochs=10, batch_size=32)

এখানে:

• model.fit() ফাংশনটি মডেলকে ট্রেনিং ডেটা (X_train এবং y_train) দিয়ে ট্রেনিং করতে সাহায্য করে।
• epochs হল প্রশিক্ষণের জন্য ডেটাসেটটি কতবার প্রক্রিয়া করা হবে।
• batch_size হল একবারে কতগুলো উদাহরণ মডেলে পাস করা হবে।

২. মডেল Evaluate করা

মডেল ট্রেনিং করার পর, এটি মূল্যায়ন করার জন্য ইভ্যালুয়েশন প্রক্রিয়া প্রয়োজন। মডেল ইভ্যালুয়েশন হল মডেলের পারফরম্যান্স পরিমাপ করার প্রক্রিয়া, যা সাধারণত টেস্ট ডেটা এর উপর ভিত্তি করে করা হয়।

২.১ মডেল Evaluate কোড:

model.evaluate() ফাংশনটি একটি মডেলকে নির্দিষ্ট টেস্ট ডেটা দিয়ে মূল্যায়ন করার জন্য ব্যবহৃত হয়।

# টেস্ট ডেটা তৈরি
X_test = np.random.rand(20, 8)  # 20 উদাহরণ, 8 ইনপুট ফিচার
y_test = np.random.randint(0, 2, 20)  # 20 লেবেল (0 বা 1)

# মডেল Evaluate করা
loss, accuracy = model.evaluate(X_test, y_test)

# ফলাফল প্রিন্ট করা
print(f'Loss: {loss}')
print(f'Accuracy: {accuracy}')

এখানে:

• model.evaluate() ফাংশনটি মডেলকে টেস্ট ডেটা (X_test, y_test) দিয়ে মূল্যায়ন করবে এবং এটি দুটি আউটপুট প্রদান করবে:
  • Loss: এটি মডেলের ভুলের পরিমাণ (যত কম হবে, তত ভালো)।
  • Accuracy: এটি মডেলের সঠিকতার পরিমাণ (যত বেশি হবে, তত ভালো)।

২.২ মেট্রিক্স (Metrics):

মডেল ট্রেনিং এবং ইভ্যালুয়েশন করার সময় মেট্রিক্স যেমন accuracy, precision, recall, F1-score ইত্যাদি ব্যবহৃত হতে পারে। Keras আপনাকে বিভিন্ন ধরনের মেট্রিক্স ব্যবহার করার সুযোগ দেয়।

উদাহরণ:

from sklearn.metrics import classification_report

# মডেল থেকে প্রেডিকশন করা
y_pred = model.predict(X_test)
y_pred_classes = (y_pred > 0.5).astype("int32")  # থ্রেশহোল্ড 0.5 দিয়ে ক্লাসিফিকেশন

# ক্লাসিফিকেশন রিপোর্ট
print(classification_report(y_test, y_pred_classes))

এখানে:

• classification_report মেট্রিক্সে precision, recall, f1-score এবং অন্যান্য মেট্রিক্স দেখা যাবে, যা মডেলের পারফরম্যান্স মূল্যায়নে সহায়তা করবে।

৩. কনফিউশন ম্যাট্রিক্স (Confusion Matrix)

কনফিউশন ম্যাট্রিক্সটি সাধারণত binary classification অথবা multi-class classification এর জন্য ব্যবহৃত হয়, যা মডেলের সঠিকতা এবং ভুলের বিষয়ে বিস্তারিত তথ্য প্রদান করে।

import matplotlib.pyplot as plt
from sklearn.metrics import confusion_matrix
import seaborn as sns

# কনফিউশন ম্যাট্রিক্স তৈরি
cm = confusion_matrix(y_test, y_pred_classes)

# কনফিউশন ম্যাট্রিক্স প্লট করা
plt.figure(figsize=(6,6))
sns.heatmap(cm, annot=True, fmt='d', cmap='Blues', xticklabels=['Class 0', 'Class 1'], yticklabels=['Class 0', 'Class 1'])
plt.xlabel('Predicted')
plt.ylabel('True')
plt.title('Confusion Matrix')
plt.show()

এখানে:

• Confusion Matrix এর মাধ্যমে আপনি মডেলের ভুল এবং সঠিক প্রেডিকশন গুলি বিশ্লেষণ করতে পারবেন, যেমন টু-টু টেকনিক্যাল রিডকশনের জন্য।

৪. মডেল Save এবং Load করা

একবার মডেল ট্রেনিং হয়ে গেলে, আপনি মডেলটি save করতে পারেন এবং পরে তা load করে আবার ব্যবহার করতে পারেন।

৪.১ মডেল সেভ করা:

# মডেল সেভ করা
model.save('model.h5')

৪.২ মডেল লোড করা:

from tensorflow.keras.models import load_model

# সেভ করা মডেল লোড করা
loaded_model = load_model('model.h5')

এটি আপনাকে একই মডেল পুনরায় লোড এবং ব্যবহার করার সুযোগ দেয়।

সারাংশ

1. মডেল ট্রেনিং: model.fit() ফাংশন ব্যবহার করে আপনার মডেলকে প্রশিক্ষণ দিন।
2. মডেল Evaluate: model.evaluate() ফাংশন ব্যবহার করে আপনার মডেলকে টেস্ট ডেটা দিয়ে মূল্যায়ন করুন।
3. মেট্রিক্স: accuracy, precision, recall এবং F1-score ইত্যাদি মেট্রিক্স মডেলের পারফরম্যান্স পরিমাপ করতে ব্যবহৃত হয়।
4. কনফিউশন ম্যাট্রিক্স: এটি মডেলের ভুল এবং সঠিক প্রেডিকশন বিশ্লেষণ করতে সহায়তা করে।
5. মডেল Save এবং Load: মডেল সেভ করে পরবর্তী সময়ে পুনরায় ব্যবহার করা সম্ভব।

এই পদক্ষেপগুলো অনুসরণ করে আপনি সহজে আপনার মডেল ট্রেনিং এবং ইভ্যালুয়েশন করতে পারবেন।